"""演示Agent系统模块

本模块包含用于演示的Agent实现，这些Agent主要用于展示系统功能，
在实际业务开发中可以根据需要进行定制或替换。

包含的演示Agent：
- DemoGlobalAgent: 演示全局查询功能
- DemoKnowledgeAgent: 演示知识库问答功能
- DemoDataAnalysisAgent: 演示数据分析功能
- DemoFormAgent: 演示表单创建功能
- DemoGeneralChatAgent: 演示通用对话功能
"""

from agents import BaseAgent, AgentConfig
from models import SessionContext, WorkflowState, DataSourceQuery, FormField, FormData
from data_sources import data_source_service
from llm_service import llm_service
from typing import Dict, Any, Optional, AsyncGenerator, List
from datetime import datetime
import logging
import uuid

logger = logging.getLogger(__name__)

class DemoBaseAgent(BaseAgent):
    """
    演示用的基础Agent类
    
    为演示场景提供通用的Agent基础功能。
    """
    pass

class DemoGlobalAgent(DemoBaseAgent):
    """
    演示用的全局Agent
    
    处理用户和部门信息查询，支持多种查询模式。
    专门用于演示企业内部信息查询功能。
    """
    
    def __init__(self):
        config = AgentConfig(
            name="global_agent",
            description="查询用户和部门信息，处理人员相关查询",
            keywords=["用户", "员工", "部门", "人员", "查询", "谁是", "联系方式"],
            data_sources=["user_list", "department_list"],
            output_types=["text"],
            priority=80,
            examples=[
                "查询张三的信息",
                "技术部有哪些人",
                "显示所有部门",
                "李四的联系方式"
            ]
        )
        super().__init__(config)
    
    async def process(
        self,
        query: str,
        context: SessionContext,
        workflow_state: Optional[WorkflowState] = None
    ) -> AsyncGenerator[Dict[str, Any], None]:
        """
        处理用户和部门查询
        
        支持多种查询模式：
        1. 用户信息查询（姓名、联系方式、职位等）
        2. 部门信息查询（部门成员、部门结构等）
        3. 组织架构查询
        
        Args:
            query: 用户查询文本
            context: 会话上下文
            workflow_state: 工作流状态（未使用）
            
        Yields:
            Dict[str, Any]: 查询结果
        """
        
        try:
            logger.info(f"DemoGlobalAgent开始处理查询: {query}")
            
            # 发送开始处理消息
            yield {
                "type": "message",
                "data": {
                    "content": f"正在使用{self.description}处理您的查询...",
                    "agent_name": self.name
                }
            }
            
            # 检测查询类型
            if any(keyword in query for keyword in ["用户", "员工", "人员", "谁是"]):
                logger.info("检测到用户查询类型")
                async for result in self._handle_user_query(query, context):
                    logger.info(f"用户查询结果类型: {type(result)}, 内容: {result}")
                    yield result
            elif any(keyword in query for keyword in ["部门", "团队", "组织"]):
                logger.info("检测到部门查询类型")
                async for result in self._handle_department_query(query, context):
                    logger.info(f"部门查询结果类型: {type(result)}, 内容: {result}")
                    yield result
            else:
                logger.info("通用查询处理")
                # 通用查询
                yield {
                    "type": "assistant",
                    "data": {
                        "content": "我可以帮您查询用户信息和部门信息。请告诉我您想了解什么？",
                        "is_final": True
                    }
                }
                
        except Exception as e:
            import traceback
            error_traceback = traceback.format_exc()
            logger.error(f"GlobalAgent处理失败: {e}\n堆栈跟踪:\n{error_traceback}")
            yield {
                "type": "error",
                "data": {
                    "error_code": "GLOBAL_AGENT_ERROR",
                    "error_message": f"查询处理失败: {str(e)}"
                }
            }
    
    async def _handle_user_query(self, query: str, context: SessionContext) -> AsyncGenerator[Dict[str, Any], None]:
        """
        处理用户查询
        
        从查询中提取用户名，查询用户数据源并返回结果。
        
        Args:
            query: 用户查询文本
            context: 会话上下文
            
        Yields:
            Dict[str, Any]: 用户查询结果
        """
        
        # 提取用户名（简单的关键词提取）
        user_name = None
        for word in query.split():
            if len(word) >= 2 and word not in ["查询", "用户", "员工", "信息", "的", "是", "谁"]:
                user_name = word
                break
        
        # 构建查询对象
        filters = {"name": user_name} if user_name else {}
        if "本部门" in query:
            filters["department"] = context.user_info.department
            
        query_obj = DataSourceQuery(
            source_type="user_list",
            filters=filters
        )
        
        # 查询数据源
        result = await data_source_service.query_data_source(query_obj)
        
        if result.data and len(result.data) > 0:
            # 格式化输出
            if len(result.data) == 1:
                user = result.data[0]
                content = f"""用户信息：
姓名：{user['name']}
部门：{user['department']}
职位：{user['position']}
邮箱：{user['email']}
电话：{user['phone']}
入职时间：{user['join_date']}"""
            else:
                content = f"找到 {len(result.data)} 个用户：\n"
                for user in result.data[:10]:  # 限制显示数量
                    content += f"• {user['name']} - {user['department']} - {user['position']}\n"
                if len(result.data) > 10:
                    content += f"... 还有 {len(result.data) - 10} 个用户"
        else:
            content = "未找到相关用户信息。"
        
        yield {
            "type": "assistant",
            "data": {
                "content": content,
                "is_final": True
            }
        }
    
    async def _handle_department_query(self, query: str, context: SessionContext) -> AsyncGenerator[Dict[str, Any], None]:
        """
        处理部门查询
        
        查询部门信息和部门成员。
        
        Args:
            query: 用户查询文本
            context: 会话上下文
            
        Yields:
            Dict[str, Any]: 部门查询结果
        """
        
        # 提取部门名
        department_name = None
        for word in query.split():
            if "部" in word or "组" in word or "团队" in word:
                department_name = word
                break
        
        # 构建查询对象
        query_obj = DataSourceQuery(
            source_type="department_list",
            filters={"name": department_name} if department_name else {}
        )
        
        # 查询数据源
        result = await data_source_service.query_data_source(query_obj)
        
        if result.data and len(result.data) > 0:
            content = "部门信息：\n"
            for dept in result.data:
                content += f"""\n部门：{dept['name']}
负责人：{dept['manager']}
人员数量：{dept['member_count']}
主要职能：{dept['description']}
"""
        else:
            content = "未找到相关部门信息。"
        
        yield {
            "type": "assistant",
            "data": {
                "content": content,
                "is_final": True
            }
        }

class DemoKnowledgeAgent(DemoBaseAgent):
    """
    演示用的知识Agent
    
    基于RAG技术进行知识问答，支持企业知识库查询。
    """
    
    def __init__(self):
        config = AgentConfig(
            name="knowledge_agent",
            description="基于知识库回答问题，提供专业知识支持",
            keywords=["知识", "文档", "规定", "流程", "政策", "如何", "什么是"],
            data_sources=["knowledge_base", "documents"],
            output_types=["text"],
            priority=70,
            examples=[
                "公司的请假流程是什么？",
                "如何申请出差？",
                "什么是绩效考核？"
            ]
        )
        super().__init__(config)
    
    async def process(
        self,
        query: str,
        context: SessionContext,
        workflow_state: Optional[WorkflowState] = None
    ) -> AsyncGenerator[Dict[str, Any], None]:
        """
        处理知识查询
        
        使用RAG技术从知识库中检索相关信息并生成回答。
        
        Args:
            query: 用户查询文本
            context: 会话上下文
            workflow_state: 工作流状态（未使用）
            
        Yields:
            Dict[str, Any]: 知识问答结果
        """
        
        try:
            # 查询知识库
            query_obj = DataSourceQuery(
                source_type="knowledge_base",
                query_params={
                    "query_text": query,
                    "similarity_threshold": 0.7
                }
            )
            
            kb_result = await data_source_service.query_data_source(query_obj)
            
            if kb_result.data and len(kb_result.data) > 0:
                # 使用LLM生成基于知识库的回答
                context_text = "\n".join([doc["content"] for doc in kb_result.data[:3]])
                
                system_prompt = f"""你是企业知识助手，请基于以下知识库内容回答用户问题：

{context_text}

请提供准确、专业的回答，如果知识库中没有相关信息，请明确说明。"""
                
                # 流式生成回答
                async for chunk in llm_service.stream_chat_completion(
                    messages=[
                        {"role": "system", "content": system_prompt},
                        {"role": "user", "content": query}
                    ],
                    temperature=0.3
                ):
                    yield {
                        "type": "assistant",
                        "data": {
                            "content": chunk,
                            "is_streaming": True,
                            "is_final": False
                        }
                    }
                
                # 发送最终消息
                yield {
                    "type": "assistant",
                    "data": {
                        "content": "",
                        "is_streaming": False,
                        "is_final": True
                    }
                }
            else:
                yield {
                    "type": "assistant",
                    "data": {
                        "content": "抱歉，我在知识库中没有找到相关信息。请尝试重新描述您的问题或联系相关部门。",
                        "is_final": True
                    }
                }
                
        except Exception as e:
            logger.error(f"KnowledgeAgent处理失败: {e}")
            yield {
                "type": "error",
                "data": {
                    "error_code": "KNOWLEDGE_AGENT_ERROR",
                    "error_message": f"知识查询失败: {str(e)}"
                }
            }

class DemoDataAnalysisAgent(DemoBaseAgent):
    """
    演示用的数据分析Agent
    
    处理数据分析请求，生成图表和分析报告。
    """
    
    def __init__(self):
        config = AgentConfig(
            name="data_analysis_agent",
            description="分析生产数据，生成图表和报告",
            keywords=["分析", "数据", "图表", "统计", "趋势", "报告"],
            data_sources=["production_data", "sales_data"],
            output_types=["text", "chart"],
            priority=65,
            examples=[
                "分析本月销售数据",
                "生成生产效率图表",
                "统计用户活跃度"
            ]
        )
        super().__init__(config)
    
    async def process(
        self,
        query: str,
        context: SessionContext,
        workflow_state: Optional[WorkflowState] = None
    ) -> AsyncGenerator[Dict[str, Any], None]:
        """
        处理数据分析请求
        
        执行数据分析流程：
        1. 查询生产数据
        2. 生成图表数据
        3. 使用LLM生成分析文本
        
        Args:
            query: 用户查询文本
            context: 会话上下文
            workflow_state: 工作流状态（未使用）
            
        Yields:
            Dict[str, Any]: 数据分析结果
        """
        
        try:
            # 查询生产数据
            query_obj = DataSourceQuery(
                source_type="production_data",
                query_params={
                    "time_range": "last_30_days",
                    "aggregation": "daily"
                }
            )
            
            data_result = await data_source_service.query_data_source(query_obj)
            
            if data_result.data and len(data_result.data) > 0:
                # 生成图表数据
                chart_data = {
                    "type": "line",
                    "title": "生产数据趋势分析",
                    "data": {
                        "labels": [item["date"] for item in data_result.data],
                        "datasets": [{
                            "label": "生产量",
                            "data": [item["production_count"] for item in data_result.data],
                            "borderColor": "rgb(75, 192, 192)",
                            "tension": 0.1
                        }]
                    }
                }
                
                yield {
                    "type": "chart",
                    "data": chart_data
                }
                
                # 使用LLM生成分析文本
                data_summary = f"数据点数量: {len(data_result.data)}, 平均生产量: {sum(item['production_count'] for item in data_result.data) / len(data_result.data):.2f}"
                
                system_prompt = f"""你是数据分析专家，请基于以下数据生成专业的分析报告：

{data_summary}

请提供数据趋势分析、关键洞察和建议。"""
                
                # 流式生成分析文本
                async for chunk in llm_service.stream_chat_completion(
                    messages=[
                        {"role": "system", "content": system_prompt},
                        {"role": "user", "content": query}
                    ],
                    temperature=0.5
                ):
                    yield {
                        "type": "assistant",
                        "data": {
                            "content": chunk,
                            "is_streaming": True,
                            "is_final": False
                        }
                    }
                
                # 发送最终消息
                yield {
                    "type": "assistant",
                    "data": {
                        "content": "",
                        "is_streaming": False,
                        "is_final": True
                    }
                }
            else:
                yield {
                    "type": "assistant",
                    "data": {
                        "content": "抱歉，无法获取相关数据进行分析。请检查数据源或联系管理员。",
                        "is_final": True
                    }
                }
                
        except Exception as e:
            logger.error(f"DataAnalysisAgent处理失败: {e}")
            yield {
                "type": "error",
                "data": {
                    "error_code": "DATA_ANALYSIS_ERROR",
                    "error_message": f"数据分析失败: {str(e)}"
                }
            }

class DemoFormAgent(DemoBaseAgent):
    """
    演示用的表单Agent
    
    专门处理各种表单的创建和管理。
    支持会议室预订、请假申请等常见业务表单。
    """
    
    def __init__(self):
        config = AgentConfig(
            name="form_agent",
            description="创建和管理各种表单，如会议预订、请假申请等",
            keywords=["创建", "申请", "预订", "表单", "会议", "请假", "报销"],
            data_sources=["meeting_rooms", "user_list"],
            output_types=["text", "form"],
            priority=60,
            examples=[
                "我要预订会议室",
                "创建请假申请",
                "申请报销"
            ]
        )
        super().__init__(config)
        
        # 表单模板定义
        self.form_templates = {
            "meeting": {
                "title": "会议室预订",
                "description": "预订会议室并安排会议",
                "fields": [
                    {"name": "title", "label": "会议主题", "type": "text", "required": True},
                    {"name": "date", "label": "会议日期", "type": "date", "required": True},
                    {"name": "start_time", "label": "开始时间", "type": "time", "required": True},
                    {"name": "end_time", "label": "结束时间", "type": "time", "required": True},
                    {"name": "room_id", "label": "会议室", "type": "select", "required": True, "options": []},
                    {"name": "participants", "label": "参会人员", "type": "textarea", "required": False},
                    {"name": "description", "label": "会议描述", "type": "textarea", "required": False}
                ]
            },
            "leave": {
                "title": "请假申请",
                "description": "提交请假申请",
                "fields": [
                    {"name": "leave_type", "label": "请假类型", "type": "select", "required": True, 
                     "options": ["年假", "病假", "事假", "调休"]},
                    {"name": "start_date", "label": "开始日期", "type": "date", "required": True},
                    {"name": "end_date", "label": "结束日期", "type": "date", "required": True},
                    {"name": "reason", "label": "请假原因", "type": "textarea", "required": True},
                    {"name": "emergency_contact", "label": "紧急联系人", "type": "text", "required": False}
                ]
            }
        }
    
    async def process(
        self,
        query: str,
        context: SessionContext,
        workflow_state: Optional[WorkflowState] = None
    ) -> AsyncGenerator[Dict[str, Any], None]:
        """
        处理表单创建请求
        
        执行表单处理流程：
        1. 检测用户需要的表单类型
        2. 获取相应的表单模板
        3. 从查询中提取可预填充的信息
        4. 生成完整的表单并返回
        
        Args:
            query: 用户查询文本
            context: 会话上下文
            workflow_state: 工作流状态（未使用）
            
        Yields:
            Dict[str, Any]: 表单数据和相关信息
        """
        
        try:
            logger.info(f"DemoFormAgent开始处理查询: {query}")
            
            # 发送开始处理消息
            yield {
                "type": "message",
                "data": {
                    "content": f"正在使用{self.description}处理您的表单请求...",
                    "agent_name": self.name
                }
            }
            
            # 检测表单类型
            form_type = self._detect_form_type(query)
            
            if not form_type:
                yield {
                    "type": "assistant",
                    "data": {
                        "content": "我可以帮您创建以下类型的表单：\n• 会议室预订\n• 请假申请\n\n请告诉我您想创建哪种表单？",
                        "is_final": True
                    }
                }
                return
            
            # 获取表单模板
            template = self.form_templates[form_type].copy()
            
            # 如果是会议室预订，需要动态填充会议室选项
            if form_type == "meeting":
                await self._populate_meeting_rooms(template)
            
            logger.info("开始提取表单数据")
            # 从用户输入中提取数据
            extraction_result = await llm_service.extract_form_data(
                query,
                template
            )
            
            logger.info(f"提取结果类型: {type(extraction_result)}, 内容: {extraction_result}")
            
            # 创建表单
            form_id = str(uuid.uuid4())
            form_fields = []
            
            for field_def in template["fields"]:
                field = FormField(
                    name=field_def["name"],
                    label=field_def["label"],
                    type=field_def["type"],
                    required=field_def["required"],
                    options=field_def.get("options"),
                    placeholder=field_def.get("placeholder")
                )
                
                # 安全地填入提取的数据
                if isinstance(extraction_result, dict):
                    extracted_data = extraction_result.get("extracted_data", {})
                    if isinstance(extracted_data, dict) and field.name in extracted_data:
                        field.value = extracted_data[field.name]
                elif isinstance(extraction_result, str):
                    logger.warning(f"表单数据提取结果为字符串类型: {extraction_result}")
                    # 如果extraction_result是字符串，跳过数据填充
                
                form_fields.append(field)
            
            # 安全地构建实体数据
            entity_data = {
                "form_type": form_type,
                "user_id": context.user_info.user_id,
                "user_name": context.user_info.name,
                "department": context.user_info.department,
                "tenant_id": context.tenant_info.tenant_id,
                "created_at": datetime.now().isoformat()
            }
            
            # 安全地添加提取的数据
            if isinstance(extraction_result, dict):
                extracted_data = extraction_result.get("extracted_data", {})
                if isinstance(extracted_data, dict):
                    entity_data.update(extracted_data)
            elif isinstance(extraction_result, str):
                logger.warning(f"无法从字符串类型的提取结果中获取数据: {extraction_result}")
            
            form_data = FormData(
                form_id=form_id,
                title=template["title"],
                description=template["description"],
                fields=form_fields,
                entity_data=entity_data,
                submit_endpoint=f"/api/forms/{form_type}/submit"
            )
            
            yield {
                "type": "form",
                "data": form_data.dict()
            }
            
            # 提供填写建议
            if isinstance(extraction_result, dict) and extraction_result.get("missing_fields"):
                missing_fields = extraction_result.get("missing_fields", [])
                suggestions = extraction_result.get("suggestions", "")
                if isinstance(missing_fields, list):
                    yield {
                        "type": "assistant",
                        "data": {
                            "content": f"表单已创建！还需要填写以下信息：{', '.join(missing_fields)}。{suggestions}",
                            "is_final": True
                        }
                    }
            else:
                yield {
                    "type": "assistant",
                    "data": {
                        "content": "表单已创建并自动填写了部分信息，请检查并完善后提交。",
                        "is_final": True
                    }
                }
            
        except Exception as e:
            import traceback
            error_traceback = traceback.format_exc()
            logger.error(f"FormAgent处理失败: {e}\n堆栈跟踪:\n{error_traceback}")
            yield {
                "type": "error",
                "data": {
                    "error_code": "FORM_AGENT_ERROR",
                    "error_message": f"表单创建失败: {str(e)}"
                }
            }
    
    def _detect_form_type(self, query: str) -> Optional[str]:
        """
        检测表单类型
        
        根据查询文本中的关键词判断用户需要的表单类型。
        
        Args:
            query: 用户查询文本
            
        Returns:
            Optional[str]: 表单类型（meeting/leave）或None
        """
        query_lower = query.lower()
        
        # 检测会议室预订相关关键词
        if any(keyword in query_lower for keyword in ["会议", "预订", "会议室"]):
            return "meeting"
        # 检测请假申请相关关键词
        elif any(keyword in query_lower for keyword in ["请假", "休假", "假期"]):
            return "leave"
        
        return None
    
    async def _populate_meeting_rooms(self, template: Dict[str, Any]):
        """
        填充会议室选项
        
        查询可用的会议室并将其作为选项添加到表单中。
        
        Args:
            template: 表单模板字典，会被直接修改
        """
        query_obj = DataSourceQuery(
            source_type="meeting_rooms",
            filters={"available_only": True}
        )
        result = await data_source_service.query_data_source(query_obj)
        
        # 找到会议室字段并安全地填充选项
        for field in template["fields"]:
            if field["name"] == "room_id":
                # 安全地将会议室数据转换为选项格式
                if result.data and isinstance(result.data, list):
                    field["options"] = [
                        f"{room['id']}:{room['name']} (容量:{room['capacity']})"
                        for room in result.data
                        if isinstance(room, dict) and 'id' in room and 'name' in room and 'capacity' in room
                    ]
                else:
                    logger.warning(f"会议室数据格式错误: {type(result.data)}, 内容: {result.data}")
                    field["options"] = ["无可用会议室"]
                break

class DemoGeneralChatAgent(DemoBaseAgent):
    """
    演示用的通用聊天Agent
    
    处理一般性对话和闲聊，作为兜底Agent。
    """
    
    def __init__(self):
        config = AgentConfig(
            name="general_chat",
            description="处理一般性对话和无法分类的查询",
            keywords=[],
            data_sources=[],
            output_types=["text"],
            priority=10,
            examples=[
                "你好",
                "谢谢",
                "其他一般性对话"
            ]
        )
        super().__init__(config)
    
    async def process(
        self,
        query: str,
        context: SessionContext,
        workflow_state: Optional[WorkflowState] = None
    ) -> AsyncGenerator[Dict[str, Any], None]:
        """
        处理通用对话
        
        使用LLM生成友好、专业的回复。
        
        Args:
            query: 用户查询文本
            context: 会话上下文
            workflow_state: 工作流状态（未使用）
            
        Yields:
            Dict[str, Any]: 通用对话回复
        """
        
        try:
            logger.info(f"DemoGeneralChatAgent开始处理查询: {query}")
            logger.info(f"用户上下文: user_id={context.user_id}, session_id={context.session_id}")
            
            system_prompt = f"""你是小U智能助手，一个专业友好的企业AI助手。

当前用户信息：
- 姓名：{context.user_info.name}
- 部门：{context.user_info.department}
- 职位：{context.user_info.position}

你可以帮助用户：
1. 查询用户和部门信息
2. 搜索知识库回答问题
3. 分析生产数据并生成图表
4. 创建各种表单（会议预订、请假申请等）

请保持专业、友好的语调，简洁明了地回答用户问题。"""
            
            logger.info("开始流式生成回答")
            # 流式生成回答
            async for chunk in llm_service.stream_chat_completion(
                messages=[
                    {"role": "system", "content": system_prompt},
                    {"role": "user", "content": query}
                ],
                temperature=0.7
            ):
                if chunk:
                    logger.debug(f"生成的chunk: {chunk}")
                    yield {
                        "type": "assistant",
                        "data": {
                            "content": chunk,
                            "is_streaming": True,
                            "is_final": False
                        }
                    }
            
            logger.info("流式生成完成")
            # 发送最终消息
            yield {
                "type": "assistant",
                "data": {
                    "content": "",
                    "is_streaming": False,
                    "is_final": True
                }
            }
            
        except Exception as e:
            import traceback
            error_traceback = traceback.format_exc()
            logger.error(f"GeneralChatAgent处理失败: {e}\n堆栈跟踪:\n{error_traceback}")
            yield {
                "type": "error",
                "data": {
                    "error_code": "GENERAL_CHAT_ERROR",
                    "error_message": f"对话处理失败: {str(e)}"
                }
            }

# 演示Agent注册表
DEMO_AGENT_REGISTRY = {
    "global_agent": DemoGlobalAgent(),
    "knowledge_agent": DemoKnowledgeAgent(),
    "data_analysis_agent": DemoDataAnalysisAgent(),
    "form_agent": DemoFormAgent(),
    "general_chat": DemoGeneralChatAgent(),
    # 技能名称映射（前端使用的简化名称）
    "global": DemoGlobalAgent(),
    "knowledge": DemoKnowledgeAgent(),
    "data_analysis": DemoDataAnalysisAgent(),
    "form": DemoFormAgent(),
    "general_chat": DemoGeneralChatAgent()
}

def get_demo_agents() -> List[Dict[str, Any]]:
    """
    获取可用演示Agent列表
    
    Returns:
        List[Dict[str, Any]]: 所有已注册演示Agent的详细信息列表
    """
    return [
        {
            "name": agent.name,
            "description": agent.description,
            "keywords": agent.keywords,
            "priority": agent.priority,
            "examples": agent.config.examples
        }
        for agent in DEMO_AGENT_REGISTRY.values()
    ]

def get_demo_agent(agent_name: str) -> Optional[DemoBaseAgent]:
    """
    根据名称获取演示Agent实例
    
    Args:
        agent_name: Agent名称
        
    Returns:
        Optional[DemoBaseAgent]: Agent实例或None
    """
    return DEMO_AGENT_REGISTRY.get(agent_name)

async def detect_demo_multi_agent_requirement(query: str) -> Optional[List[str]]:
    """
    检测是否需要多Agent协作（演示版本）
    
    通过LLM语义理解判断用户查询是否需要多个Agent协同处理。
    
    Args:
        query: 用户查询文本
        
    Returns:
        Optional[List[str]]: 需要协作的Agent列表，如果不需要协作则返回None
    """
    
    from llm_service import llm_service
    
    # 定义可用的Agent及其功能描述
    agent_descriptions = {
        "global_agent": "处理用户信息查询、员工管理、部门信息等全局数据操作",
        "knowledge_agent": "处理知识库查询、文档搜索、问答等知识管理功能", 
        "data_analysis_agent": "处理数据分析、图表生成、统计报告等分析功能",
        "form_agent": "处理表单创建、申请提交、预订等表单相关功能"
    }
    
    prompt = f"""请分析以下用户查询，判断是否需要多个Agent协作完成任务。

用户查询："{query}"

可用的Agent及其功能：
{chr(10).join([f"- {name}: {desc}" for name, desc in agent_descriptions.items()])}

请按以下格式回答：
1. 如果只需要单个Agent，回答：SINGLE_AGENT
2. 如果需要多个Agent协作，回答：MULTI_AGENT: [agent1, agent2, ...]

判断标准：
- 如果查询涉及多个不同领域的操作（如：先查询信息，再创建表单），则需要多Agent协作
- 如果查询只涉及单一领域的操作，则使用单Agent
- 特别注意包含"并"、"然后"、"接着"等连接词的复合任务

示例：
- "查找张三的信息" → SINGLE_AGENT
- "创建请假申请" → SINGLE_AGENT  
- "查找张三的信息并为他创建请假申请" → MULTI_AGENT: [global_agent, form_agent]
"""
    
    try:
        logger.info(f"开始LLM多Agent检测，查询: {query}")
        response = await llm_service.chat_completion(
            messages=[{"role": "user", "content": prompt}],
            temperature=0.1,
            max_tokens=200
        )
        
        # 提取响应内容
        if isinstance(response, dict) and 'choices' in response:
            result = response['choices'][0]['message']['content'].strip()
        else:
            result = str(response).strip()
        
        logger.info(f"LLM响应: {result}")
        
        if result.startswith("MULTI_AGENT:"):
            # 提取Agent列表
            agents_part = result.split("MULTI_AGENT:")[1].strip()
            # 移除方括号并分割
            agents_part = agents_part.strip("[]")
            agents = [agent.strip() for agent in agents_part.split(",")]
            # 过滤有效的Agent名称
            valid_agents = [agent for agent in agents if agent in agent_descriptions]
            logger.info(f"LLM检测到的Agent: {valid_agents}")
            return valid_agents if len(valid_agents) >= 2 else None
        else:
            logger.info("LLM判断为单Agent任务")
            return None
            
    except Exception as e:
        logger.error(f"LLM多Agent检测失败: {e}")
        # 降级到简单的关键词检测
        logger.info("降级到关键词检测")
        return _fallback_keyword_detection(query)

def _fallback_keyword_detection(query: str) -> Optional[List[str]]:
    """
    降级的关键词检测方法
    """
    logger.info(f"使用关键词检测，查询: {query}")
    query_lower = query.lower()
    required_agents = []
    
    # 简单的关键词检测
    if any(keyword in query_lower for keyword in ["用户", "员工", "张三", "李四", "查找", "信息"]):
        required_agents.append("global_agent")
    
    if any(keyword in query_lower for keyword in ["创建", "申请", "表单", "请假"]):
        required_agents.append("form_agent")
    
    if any(keyword in query_lower for keyword in ["分析", "数据", "统计"]):
        required_agents.append("data_analysis_agent")
    
    if any(keyword in query_lower for keyword in ["知识", "文档", "搜索"]):
        required_agents.append("knowledge_agent")
    
    # 检查复合查询的连接词
    if any(keyword in query_lower for keyword in ["并", "然后", "接着", "再"]):
        result = list(dict.fromkeys(required_agents)) if len(required_agents) >= 2 else None
        logger.info(f"关键词检测结果: {result}")
        return result
    
    logger.info("关键词检测：单Agent任务")
    return None

def requires_demo_human_confirmation(agent_name: str, action_type: str, context: Dict[str, Any]) -> bool:
    """
    判断是否需要人工确认（演示版本）
    
    根据Agent类型和操作类型判断是否需要人工确认。
    
    Args:
        agent_name: Agent名称
        action_type: 操作类型
        context: 操作上下文信息
        
    Returns:
        bool: 是否需要人工确认
    """
    
    # 高风险操作需要确认
    high_risk_actions = {
        "form_agent": ["submit_form", "book_meeting", "create_leave_request"],
        "data_analysis_agent": ["export_data", "generate_report"],
        "global_agent": ["modify_user_info", "update_department"]
    }
    
    if agent_name in high_risk_actions:
        if action_type in high_risk_actions[agent_name]:
            return True
    
    # 涉及敏感数据的操作
    if context.get("involves_sensitive_data", False):
        return True
    
    # 影响多个用户的操作
    if context.get("affects_multiple_users", False):
        return True
    
    # 不可逆操作
    if context.get("irreversible_action", False):
        return True
    
    return False